home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / tctutor2.zip / DATA.C < prev    next >
C/C++ Source or Header  |  1987-07-04  |  15KB  |  447 lines
  1. /*    DATA.C   DATA.C    DATA.C    DATA.C    DATA.C    DATA.C
  2.  
  3. DATA INITIALIZE AND CALCULATE      XXXX     X    XXXXX    X
  4.                                    X   X   X X     X     X X
  5. July 1, 1987                       X   X  X   X    X    X   X
  6.                                    X   X  X   X    X    X   X
  7.                                    X   X  XXXXX    X    XXXXX
  8.                                    X   X  X   X    X    X   X
  9.                                    XXXX   X   X    X    X   X
  10. */
  11. #include "ctype.h"
  12. #include "string.h"
  13. #include "math.h"
  14. #include "struct.def"
  15. #include "defin.h"
  16.  
  17. extern struct vars allvars[];
  18. extern char inline[];
  19. extern int col;
  20. extern int errcode,colerr;
  21. extern char strngout[];
  22. extern int valattr;
  23.  
  24. /* ****************************************************** initdata */
  25. /* This function is used to initialize all of the variables to the */
  26. /* starting values including their variable names.                 */
  27. void initdata(struct vars *pnt)
  28. {
  29. int index;
  30.     for (index = 0;index < 6;++index){
  31.        (pnt+index)->varname[0] = 'A' + index;
  32.        (pnt+index)->varname[1] = 0;
  33.        (pnt+index)->outtype = 'F';
  34.        (pnt+index)->value = 0.0;
  35.     }
  36.     for (index = 6;index < 12;++index){
  37.        (pnt+index)->varname[0] = 'I' + index - 6;
  38.        (pnt+index)->varname[1] = 0;
  39.        (pnt+index)->outtype = 'D';
  40.        (pnt+index)->value = 0;
  41.     }
  42.     (pnt+4)->value = 2.718281828459045;
  43.     (pnt+5)->value = 3.141592653589793;
  44.     (pnt+11)->value = 16777215;
  45. }
  46.  
  47. /* ******************************************************* getnames */
  48. /* This function reads in a new list of variable names to be used   */
  49. /* in place of the names A to F. This is only as a convenience for  */
  50. /* the user, so he can use more meaningful names.                   */
  51. void getnames(void)
  52. {
  53. char var,index;
  54. char dummy[80];
  55.  
  56.    col = 1;                      /* skip over and ignore the # sign */
  57.    do {
  58.       if (inline[col] == ' ') col++;   /* ignore all leading blanks */
  59.       else {
  60.          var = inline[col] - 'A';
  61.          if ((var >= 0) && (var <= 5)) {             /* A through F */
  62.             col++;
  63.             if (inline[col] != '-') {           /* should be a dash */
  64.                errchk(14);
  65.                errout();
  66.                return;
  67.             }
  68.             col++;
  69.             for (index = 0;index < 6;index++)
  70.                if (isalpha(inline[col]) || isdigit(inline[col])) {
  71.                   dummy[index] = inline[col];
  72.                   dummy[index + 1] = 0;
  73.                   col++;
  74.                }
  75.             if (index > 0) {
  76.                strcpy(allvars[var].varname,dummy);
  77.                strcpy(strngout,"      ");         /* this is for    */
  78.                strngout[6-strlen(dummy)] = 0;     /* leading blanks */
  79.                strcat(strngout,dummy);
  80.                strngdis(var + 1,1,valattr);
  81.             }
  82.          }
  83.          else if ((var >= 8) && (var <= 13)) {       /* I through N */
  84.             col++;
  85.             if (inline[col] != '-') {           /* should be a dash */
  86.                errchk(14);
  87.                errout();
  88.                return;
  89.             }
  90.             col++;
  91.             if ((inline[col] == 'O') || (inline[col] == 'D') ||
  92.                 (inline[col] == 'H') || (inline[col] == 'X')) {
  93.                var -= 2;
  94.                allvars[var].outtype = inline[col];
  95.                col++;
  96.             }
  97.             else {
  98.                errchk(15);
  99.                errout();
  100.                return;
  101.             }
  102.          }
  103.          else {                            /* unknown variable name */
  104.             errchk(3);
  105.             errout();
  106.             return;
  107.          }
  108.       }
  109.    } while (inline[col] && (errcode == 0));
  110. }
  111.  
  112. /* ******************************************************* calcdata */
  113. /* This is the function that actually does the work of deciding     */
  114. /* what calculations need to be done. The method used is described  */
  115. /* in detail below.                                                 */
  116. /*    Three variables and two operators are         number1         */
  117. /*    stored as per the list. "op1" is always         op1           */
  118. /*    a plus or minus, and op2 is always a          number2         */
  119. /*    multiplication or divide. If a plus or          op2           */
  120. /*    minus is found for op2, number1 and           number3         */
  121. /*    number2 are combined according to op1                         */
  122. /*    and the result becomes number1, the new op2 becomes op1, and  */
  123. /*    number3 becomes number2. If op2 is either a multiplication or */
  124. /*    divide, number2 and number3 are combined according to op2 and */
  125. /*    the result is placed in number2. When a parentheses is found, */
  126. /*    a recursive call is made and the expression in the parenthe-  */
  127. /*    ses is evaluated. A bit of study will be very fruitful in     */
  128. /*    understanding this operation.                                 */
  129. void calcdata(double *newval)
  130. {
  131. double number1,number2,number3,getnum();
  132. char op1,op2,getop();
  133.    number1 = 0.0;
  134.    op1 = '+';
  135.    number2 = 0.0;
  136.    while (inline[col] == ' ') col++;               /* ignore blanks */
  137.                                         /* check for unary operator */
  138.    if ((inline[col] == '+') || (inline[col] == '-')) {
  139.       op1 = inline[col];
  140.       col++;
  141.    }
  142.  
  143.    number2 = getnum();          /* (inline[col]== 0 ) = End of line */
  144.                                 /* (inline[col]=='$') = End of line */
  145.    if ((inline[col] == 0) || (inline[col] =='$')) {
  146.       calcdat(&number1,&op1,&number2);
  147.       *newval = number1;
  148.       return;
  149.    }
  150.    for (;;){
  151.       op2 = getop();
  152.       col++;
  153.                                /* check for end of line  0, ), or $ */
  154.       if (op2 == '$') op2 = 0;        /* force a $ to lool like eol */
  155.       if ((op2 == 0) || (op2 == ')')) {
  156.          col++;
  157.          calcdat(&number1,&op1,&number2);
  158.          *newval = number1;
  159.          return;
  160.       }
  161.       number3 = getnum();
  162.       if ((op2 == '*') || (op2 == '/')){
  163.          calcdat(&number2,&op2,&number3);
  164.       }
  165.       else{
  166.          calcdat(&number1,&op1,&number2);
  167.          op1 = op2;
  168.          number2 = number3;
  169.       }
  170.    } /* end of infinite for loop */
  171. }
  172.  
  173. /* ******************************************************** calcdat */
  174. /* This function actually does the calculations described in the    */
  175. /* function above.                                                  */
  176. void calcdat(double *number1,char *op1,double *number2)
  177. {
  178.    switch (*op1) {
  179.       case '*' : *number1 = (*number1)*(*number2);
  180.                  break;
  181.       case '/' : if (*number2 == 0.0) {
  182.                      errchk(10);
  183.                      break;
  184.                  }
  185.                  *number1 = (*number1)/(*number2);
  186.                  break;
  187.       case '+' : *number1 = *number1 + *number2;
  188.                  break;
  189.       case '-' : *number1 = *number1 - *number2;
  190.                  break;
  191.       default  : break;
  192.    }
  193.    return;
  194. }
  195.  
  196. /* ********************************************************* getnum */
  197. /* This is the workhorse of the program. It actually scans the data */
  198. /* input field and converts the data into numbers which are in the  */
  199. /* internal format of the computer so the calculations can be done. */
  200. double getnum(void)
  201. {
  202. int index,i,decpt;
  203. double newval;
  204. char name[7];
  205. double sqrt(), exp(), log(), sin(), cos(), atan();
  206.  
  207.    while (inline[col] == ' ') col++;               /* ignore blanks */
  208.  
  209.    index = inline[col];
  210.    if (index == '('){
  211.        col++;
  212.        calcdata(&newval);                         /* recursive call */
  213.        col--;
  214.        return(newval);
  215.    }
  216.  
  217.    decpt = 0;                         /* search for a decimal point */
  218.    i = col;
  219.    index = inline[i];
  220.    while ((index >= '0') && (index <= '9')) {
  221.       i++;
  222.       index = inline[i];
  223.       if (index == '.') decpt = 1;
  224.    }
  225.  
  226.    index = inline[col];
  227.    if (((index > '0') && (index <= '9')) ||
  228.        ((index == '0') && (decpt == 1))  ||
  229.         (index == '.')) {